# [十二] Spring的事务管理 - 声明式事务

@Component
@EnableTransactionManagement(proxyTargetClass = false)
@MapperScan(basePackages = {"com.xiangxue.jack.dao"},annotationClass = Repository.class)
public class EnableTransactionManagementBean {

   /*
    *  以下两个@Bean的配置都可以设置数据源
    *  通过SqlSessionFactoryBean设置数据源
    */
    @Bean
    public SqlSessionFactoryBean sqlSessionFactoryBean(DataSource dataSource) {
        SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
        sqlSessionFactoryBean.setDataSource(dataSource);
        return sqlSessionFactoryBean;
    }

   /*
    *  通过事务管理平台的方式设置数据源
    */
    @Bean
    public PlatformTransactionManager annotationDrivenTransactionManager(DataSource dataSource) {
        DataSourceTransactionManager dtm = new DataSourceTransactionManager();
        dtm.setDataSource(dataSource);
        return dtm;
    }

}

@Configuration
@PropertySource("classpath:config/core/core.properties")
public class DataSourceConfiguration {

    @Value("${jdbc.driverClassName}")
    private String driverClass;
    @Value("${jdbc.url:jdbc}")
    private String jdbcUrl;
    @Value("${jdbc.username}")
    private String user;
    @Value("${jdbc.password}")
    private String password;

    @Bean
    public DataSource comboPooledDataSource() {
        ComboPooledDataSource comboPooledDataSource = new ComboPooledDataSource();
        try {
            comboPooledDataSource.setDriverClass(driverClass);
            comboPooledDataSource.setJdbcUrl(jdbcUrl);
            comboPooledDataSource.setUser(user);
            comboPooledDataSource.setPassword(password);
            comboPooledDataSource.setMinPoolSize(10);
            comboPooledDataSource.setMaxPoolSize(100);
            comboPooledDataSource.setMaxIdleTime(1800);
            comboPooledDataSource.setAcquireIncrement(3);
            comboPooledDataSource.setMaxStatements(1000);
            comboPooledDataSource.setInitialPoolSize(10);
            comboPooledDataSource.setIdleConnectionTestPeriod(60);
            comboPooledDataSource.setAcquireRetryAttempts(30);
            comboPooledDataSource.setBreakAfterAcquireFailure(false);
            comboPooledDataSource.setTestConnectionOnCheckout(false);
            comboPooledDataSource.setAcquireRetryDelay(100);
        } catch (PropertyVetoException e) {
            e.printStackTrace();
        }

        return comboPooledDataSource;
    }
}

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import(TransactionManagementConfigurationSelector.class)
public @interface EnableTransactionManagement {
	// proxyTargetClass = false 表示是JDK动态代理支持接口代理。
	// true表示是Cglib代理支持子类继承代理。
	boolean proxyTargetClass() default false;
	// 事务通知模式(切面织入方式)，默认代理模式（同一个类中方法互相调用拦截器不会生效）
	AdviceMode mode() default AdviceMode.PROXY;
	// 连接点上有多个通知时，排序，默认最低。值越大优先级越低。
	int order() default Ordered.LOWEST_PRECEDENCE;

}

public class TransactionManagementConfigurationSelector extends AdviceModeImportSelector<EnableTransactionManagement> {

	@Override
	protected String[] selectImports(AdviceMode adviceMode) {
		/**
		 *  TODO : 导入需要加载的类
		 *  1、AutoProxyRegistrar: 给容器中注册一个InfrastructureAdvisorAutoProxyCreator(Spring事务入口类) 组件；
		 *  利用后置处理器机制在对象创建以后，包装对象，返回一个代理对象（增强器），
		 *  代理对象执行方法利用拦截器链进行调用；
		 *
		 *  2、ProxyTransactionManagementConfiguration: 就是一个配置类，定义了事务增强器、拦截器。
		 *
		 */
		switch (adviceMode) {
			case PROXY:
				// 重点看这2个类：
				// AutoProxyRegistrar
				// ProxyTransactionManagementConfiguration
				return new String[] {AutoProxyRegistrar.class.getName(),
						ProxyTransactionManagementConfiguration.class.getName()};
			case ASPECTJ:
				return new String[] {determineTransactionAspectClass()};
			default:
				return null;
		}
	}

	private String determineTransactionAspectClass() {
		return (ClassUtils.isPresent("javax.transaction.Transactional", getClass().getClassLoader()) ?
				TransactionManagementConfigUtils.JTA_TRANSACTION_ASPECT_CONFIGURATION_CLASS_NAME :
				TransactionManagementConfigUtils.TRANSACTION_ASPECT_CONFIGURATION_CLASS_NAME);
	}

}

protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
// 看这个 invokeBeanFactoryPostProcessors 方法
PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());

		if (beanFactory.getTempClassLoader() == null && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
			beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
			beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
		}
	}

public static void invokeBeanFactoryPostProcessors(
			ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {
			
   /** ...... 省略 ......  **/
   /**
    * 调用过程
    * 在这里典型的 BeanDefinitionRegistryPostProcessor 就是 ConfigurationClassPostProcessor
    * 用于进行bean定义的加载 比如我们的包扫描，@import等
    * @EnableAspectJAutoProxy 注解中的 AspectJAutoProxyRegistrar 类就是通过此方法调用执行
    * @EnableTransactionManagement 注解中的 TransactionManagementConfigurationSelector 类就是通过此方法调用执行
    */
	invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
	// 调用完之后，马上clear
	currentRegistryProcessors.clear();			
}

private static void invokeBeanDefinitionRegistryPostProcessors(
			Collection<? extends BeanDefinitionRegistryPostProcessor> postProcessors, BeanDefinitionRegistry registry) {

		for (BeanDefinitionRegistryPostProcessor postProcessor : postProcessors) {
			// 重点看这个方法
			postProcessor.postProcessBeanDefinitionRegistry(registry);
		}
	}

public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) {
		int registryId = System.identityHashCode(registry);
		if (this.registriesPostProcessed.contains(registryId)) {
			throw new IllegalStateException(
					"postProcessBeanDefinitionRegistry already called on this post-processor against " + registry);
		}
		if (this.factoriesPostProcessed.contains(registryId)) {
			throw new IllegalStateException(
					"postProcessBeanFactory already called on this post-processor against " + registry);
		}
		this.registriesPostProcessed.add(registryId);
		// 重点看这个方法
		processConfigBeanDefinitions(registry);
	}

public void processConfigBeanDefinitions(BeanDefinitionRegistry registry) {
	 /** ...... 省略 ......  **/
	do {
			// 进入parse方法
			parser.parse(candidates);
			parser.validate();
	}
	while (!candidates.isEmpty());
}

private void processImports(ConfigurationClass configClass, SourceClass currentSourceClass,
			Collection<SourceClass> importCandidates, boolean checkForCircularImports) {
	 /** ...... 省略 ......  **/
	if (candidate.isAssignable(ImportSelector.class)) {
	// Candidate class is an ImportSelector -> delegate to it to determine imports
	Class<?> candidateClass = candidate.loadClass();
	// 反射拿到 ImportSelector 接口类的实例化对象 selector
	ImportSelector selector = BeanUtils.instantiateClass(candidateClass, ImportSelector.class);
	ParserStrategyUtils.invokeAwareMethods(
			selector, this.environment, this.resourceLoader, this.registry);
	if (selector instanceof DeferredImportSelector) {
		this.deferredImportSelectorHandler.handle(
				configClass, (DeferredImportSelector) selector);
	}
	else {
	/*
	 * 然后通过 selector调用其实现类 AdviceModeImportSelector
	 * 的selectImports方法，模板中的钩子方法。最后拿到返回的
	 * TransactionManagementConfigurationSelector的selectImports
	 * 方法返回的两个类：
	 *  1、AutoProxyRegistrar.class
	 *  2、ProxyTransactionManagementConfiguration.class
     *  继续递归调用当前的 processImports 方法
     */
		String[] importClassNames = selector.selectImports(currentSourceClass.getMetadata());
		Collection<SourceClass> importSourceClasses = asSourceClasses(importClassNames);
		processImports(configClass, currentSourceClass, importSourceClasses, false);
	}
}
   
    }

public final String[] selectImports(AnnotationMetadata importingClassMetadata) {
		Class<?> annType = GenericTypeResolver.resolveTypeArgument(getClass(), AdviceModeImportSelector.class);
		Assert.state(annType != null, "Unresolvable type argument for AdviceModeImportSelector");

		AnnotationAttributes attributes = AnnotationConfigUtils.attributesFor(importingClassMetadata, annType);
		if (attributes == null) {
			throw new IllegalArgumentException(String.format(
					"@%s is not present on importing class '%s' as expected",
					annType.getSimpleName(), importingClassMetadata.getClassName()));
		}

		AdviceMode adviceMode = attributes.getEnum(getAdviceModeAttributeName());
		// 此方法最终会调用TransactionManagementConfigurationSelector
		// 的 selectImports方法
		String[] imports = selectImports(adviceMode);
		if (imports == null) {
			throw new IllegalArgumentException("Unknown AdviceMode: " + adviceMode);
		}
		return imports;
	}

public class TransactionManagementConfigurationSelector extends AdviceModeImportSelector<EnableTransactionManagement> {
	@Override
	protected String[] selectImports(AdviceMode adviceMode) {
		/**
		 *  TODO : 导入需要加载的类
		 *  1、AutoProxyRegistrar: 给容器中注册一个InfrastructureAdvisorAutoProxyCreator 组件；
		 *  利用后置处理器机制在对象创建以后，包装对象，返回一个代理对象（增强器），
		 *  代理对象执行方法利用拦截器链进行调用；
		 *
		 *  2、ProxyTransactionManagementConfiguration: 就是一个配置类，定义了事务增强器、拦截器。
		 *
		 */
		switch (adviceMode) {
			case PROXY:
				// 重点看这2个类：
				// AutoProxyRegistrar
				// ProxyTransactionManagementConfiguration
				return new String[] {AutoProxyRegistrar.class.getName(),
						ProxyTransactionManagementConfiguration.class.getName()};
			case ASPECTJ:
				return new String[] {determineTransactionAspectClass()};
			default:
				return null;
		}
	}
}

public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
		boolean candidateFound = false;
		// 循环遍历导入类上使用的所有注解（主要处理注解中有 mode和 proxyTargetClass属性的）
		Set<String> annoTypes = importingClassMetadata.getAnnotationTypes();
		for (String annoType : annoTypes) {
			AnnotationAttributes candidate = AnnotationConfigUtils.attributesFor(importingClassMetadata, annoType);
			if (candidate == null) {
				continue;
			}
			// 获取注解中的 mode 属性
			Object mode = candidate.get("mode");
			// 获取注解中的 proxyTargetClass 属性
			Object proxyTargetClass = candidate.get("proxyTargetClass");
			if (mode != null && proxyTargetClass != null && AdviceMode.class == mode.getClass() &&
					Boolean.class == proxyTargetClass.getClass()) {
				candidateFound = true;
				// 如果 mode 是代理模式
				if (mode == AdviceMode.PROXY) {
					// 注册事务AOP的入口类 InfrastructureAdvisorAutoProxyCreator,实际上这个AOP入口类起不了作用
					AopConfigUtils.registerAutoProxyCreatorIfNecessary(registry);
					if ((Boolean) proxyTargetClass) {
						AopConfigUtils.forceAutoProxyCreatorToUseClassProxying(registry);
						return;
					}
				}
			}
		}
	
	}

@Configuration
public class ProxyTransactionManagementConfiguration extends AbstractTransactionManagementConfiguration {

	@Bean(name = TransactionManagementConfigUtils.TRANSACTION_ADVISOR_BEAN_NAME)
	@Role(BeanDefinition.ROLE_INFRASTRUCTURE)
	//
	/**
	 * TODO : 定义事务增强器(事务织入)
	 *
	 * 定义了一个 advisor，设置事务属性、设置事务拦截器 TransactionInterceptor、设置顺序。
	 * 核心就是事务拦截器 TransactionInterceptor。
	 */
	public BeanFactoryTransactionAttributeSourceAdvisor transactionAdvisor() {
		BeanFactoryTransactionAttributeSourceAdvisor advisor = new BeanFactoryTransactionAttributeSourceAdvisor();
		advisor.setTransactionAttributeSource(transactionAttributeSource());
		advisor.setAdvice(transactionInterceptor());
		if (this.enableTx != null) {
			advisor.setOrder(this.enableTx.<Integer>getNumber("order"));
		}
		return advisor;
	}

	@Bean
	@Role(BeanDefinition.ROLE_INFRASTRUCTURE)
	// 主要负责解析 @Transactional注解里的属性资源
	// 并包装为 TransactionAttribute 类型
	public TransactionAttributeSource transactionAttributeSource() {
		return new AnnotationTransactionAttributeSource();
	}

	@Bean
	@Role(BeanDefinition.ROLE_INFRASTRUCTURE)
	// 定义事务拦截器
	public TransactionInterceptor transactionInterceptor() {
		// TransactionInterceptor 实现了 MethodInterceptor 接口，
		// 在链式调用中会自动调用它的 invoke 方法
		TransactionInterceptor interceptor = new TransactionInterceptor();
		// 设置 TransactionAttribute 属性
		interceptor.setTransactionAttributeSource(transactionAttributeSource());
		// 如果当前事务管理器不为空，设置当前事务管理器到拦截器中
		// 事务管理器和数据源绑定，此处可以自定义
		if (this.txManager != null) {
			interceptor.setTransactionManager(this.txManager);
		}
		return interceptor;
	}

}

	/**
	 *  TODO : 事务拦截器的拦截方法
	 * 事务拦截器TransactionInterceptor回调方法invoke通过调用TransactionAspectSupport事务切面支持类中的
	 * createTransactionIfNecessary和prepareTransactionInfo方法创建事务对象
	 */
	public Object invoke(MethodInvocation invocation) throws Throwable {
		// Work out the target class: may be {@code null}.
		// The TransactionAttributeSource should be passed the target class
		// as well as the method, which may be from an interface.
		// 通过 AOP获取事务的目标类
		Class<?> targetClass = (invocation.getThis() != null ? AopUtils.getTargetClass(invocation.getThis()) : null);

		// Adapt to TransactionAspectSupport's invokeWithinTransaction...
		// 核心方法，调用内部事务处理，实际调用父类 TransactionAspectSupport的 invokeWithinTransaction方法
		return invokeWithinTransaction(invocation.getMethod(), targetClass, invocation::proceed);
	}

/**
 * TODO : 调用内部事务
 */
protected Object invokeWithinTransaction(Method method, @Nullable Class<?> targetClass,
			final InvocationCallback invocation) throws Throwable {

		// If the transaction attribute is null, the method is non-transactional.
		// 通过事务属性源 TransactionAttributeSource读取事务的属性配置（名称匹配）
		TransactionAttributeSource tas = getTransactionAttributeSource();
		// 获取对应事务属性.如果事务属性为空（则目标方法不存在事务）
		// 事务属性源 NameMatchTransactionAttributeSource 的方法
		final TransactionAttribute txAttr = (tas != null ? tas.getTransactionAttribute(method, targetClass) : null);
		// 根据事务的属性获取 beanFactory 中的 PlatformTransactionManager (spring事务管理器的顶级接口)，
		// 获取 Spring事务管理IoC容器配置的事务处理器
		// 一般常用实现是 DataSourceTransactiuonManager
		final PlatformTransactionManager tm = determineTransactionManager(txAttr);
		// 目标方法唯一标识（类.方法，如service.ServiceImpl.add）
		// 获取目标类指定方法的事务连接点
		final String joinpointIdentification = methodIdentification(method, targetClass, txAttr);
		/*
		 * 区分不同类型的 PlatformTransactionManager事务处理器，不同类型的事务处理器调用方式不同。对
		 * CallbackPreferringPlatformTransactionManager，需要回调函数来实现事务的创建和提交，对非
		 * CallbackPreferringPlatformTransactionManager来说，则不需要使用回调函数来实现事务处理。
		 */
		// 如果txAttr为空或者tm 属于非CallbackPreferringPlatformTransactionManager类型的事务处理器
		// 声明式事务的操作
		if (txAttr == null || !(tm instanceof CallbackPreferringPlatformTransactionManager)) {
			// Standard transaction demarcation with getTransaction and commit/rollback calls.
			// 使用 getTransaction 和 提交/回滚 调用的标准事务划分。
			// 创建事务，将当前事务状态和信息保存到TransactionInfo对象中，重要
			TransactionInfo txInfo = createTransactionIfNecessary(tm, txAttr, joinpointIdentification);
			Object retVal = null;
			try {
				// This is an around advice: Invoke the next interceptor in the chain.
				// This will normally result in a target object being invoked.
				// 这里就是一个环绕增强，在这个proceed前后可以自己定义增强实现。
				// 回调方法执行，执行目标方法（原有的业务逻辑）
				retVal = invocation.proceedWithInvocation();
			}
			catch (Throwable ex) {
				// target invocation exception
				// 根据事务定义的，该异常需要回滚就回滚，否则提交事务
				completeTransactionAfterThrowing(txInfo, ex);
				throw ex;
			}
			finally {
				// 清空当前事务信息，重置为老的
				cleanupTransactionInfo(txInfo);
			}
			// 返回结果之前提交事务
			commitTransactionAfterReturning(txInfo);
			return retVal;
		}
		// 编程式事务
		// CallbackPreferringPlatformTransactionManager类型的事务处理器
		else {
			final ThrowableHolder throwableHolder = new ThrowableHolder();

			// It's a CallbackPreferringPlatformTransactionManager: pass a TransactionCallback in.
			try {
				// 执行实现T ransactionCallback 接口的 doInTransaction 回调方法
				Object result = ((CallbackPreferringPlatformTransactionManager) tm).execute(txAttr, status -> {
					TransactionInfo txInfo = prepareTransactionInfo(tm, txAttr, joinpointIdentification, status);
					try {
						// 拦截器链调用处理，使得最后目标对象的方法得到调用
						return invocation.proceedWithInvocation();
					}
					catch (Throwable ex) {
						// 如果事务满足对异常进行回滚处理条件
						if (txAttr.rollbackOn(ex)) {
							// A RuntimeException: will lead to a rollback.
							// 如果异常是运行时异常，则事务回滚处理
							if (ex instanceof RuntimeException) {
								throw (RuntimeException) ex;
							}
							//如果不是运行时异常，则提交处理
							else {
								throw new ThrowableHolderException(ex);
							}
						}
						else {
							// A normal return value: will lead to a commit.
							// 提交处理
							throwableHolder.throwable = ex;
							return null;
						}
					}
					//清除当前线程绑定的事务信息
					finally {
						cleanupTransactionInfo(txInfo);
					}
				}); // 到这里都是execute方法

				// Check result state: It might indicate a Throwable to rethrow.
				// 如果是ThrowableHolder类型的异常，则转换为Throwable抛出，上抛异常
				if (throwableHolder.throwable != null) {
					throw throwableHolder.throwable;
				}
				// 否则异常不做处理直接抛出
				return result;
			}
			catch (ThrowableHolderException ex) {
				throw ex.getCause();
			}
			catch (TransactionSystemException ex2) {
				if (throwableHolder.throwable != null) {
					logger.error("Application exception overridden by commit exception", throwableHolder.throwable);
					ex2.initApplicationException(throwableHolder.throwable);
				}
				throw ex2;
			}
			catch (Throwable ex2) {
				if (throwableHolder.throwable != null) {
					logger.error("Application exception overridden by commit exception", throwableHolder.throwable);
				}
				throw ex2;
			}
		}
	}

	public TransactionAttribute getTransactionAttribute(Method method, @Nullable Class<?> targetClass) {
		if (method.getDeclaringClass() == Object.class) {
			return null;
		}

		// 首先看是否存在缓存值
		Object cacheKey = getCacheKey(method, targetClass);
		TransactionAttribute cached = this.attributeCache.get(cacheKey);
		if (cached != null) {
			// 如果缓存的是一个无事务对象，直接返回 null
			if (cached == NULL_TRANSACTION_ATTRIBUTE) {
				return null;
			}
			else {
				return cached;
			}
		}
		// 缓存中不存在
		else {
			// 重新计算 TransactionAttribute 属性，根据方法和类的类型获取事务信息
			TransactionAttribute txAttr = computeTransactionAttribute(method, targetClass);
			// 存到缓存中
			if (txAttr == null) {
				this.attributeCache.put(cacheKey, NULL_TRANSACTION_ATTRIBUTE);
			}
			else {
				String methodIdentification = ClassUtils.getQualifiedMethodName(method, targetClass);
				if (txAttr instanceof DefaultTransactionAttribute) {
					((DefaultTransactionAttribute) txAttr).setDescriptor(methodIdentification);
				}
				if (logger.isTraceEnabled()) {
					logger.trace("Adding transactional method '" + methodIdentification + "' with attribute: " + txAttr);
				}
				// 将事务对象属性放到缓存中，缓存的key与类的类型和方法相关
				this.attributeCache.put(cacheKey, txAttr);
			}
			return txAttr;
		}
	}

	protected TransactionAttribute computeTransactionAttribute(Method method, @Nullable Class<?> targetClass) {
		// 如果被代理方法非public类型，则直接返回空，Spring事务不支持非public类型方法
		if (allowPublicMethodsOnly() && !Modifier.isPublic(method.getModifiers())) {
			return null;
		}

		// 方法可能在接口上，但是我们需要目标类的属性。
		// 如果目标类为空，则方法将保持不变。
		Method specificMethod = AopUtils.getMostSpecificMethod(method, targetClass);

		// First try is the method in the target class.
		// 解析方法上的 @Transactional 属性
		TransactionAttribute txAttr = findTransactionAttribute(specificMethod);
		if (txAttr != null) {
			return txAttr;
		}

		// Second try is the transaction attribute on the target class.
		// 如果方法上没有事务属性，就从类上来获取
		txAttr = findTransactionAttribute(specificMethod.getDeclaringClass());
		if (txAttr != null && ClassUtils.isUserLevelMethod(method)) {
			return txAttr;
		}

		if (specificMethod != method) {
			// Fallback is to look at the original method.
			txAttr = findTransactionAttribute(method);
			if (txAttr != null) {
				return txAttr;
			}
			// Last fallback is the class of the original method.
			txAttr = findTransactionAttribute(method.getDeclaringClass());
			if (txAttr != null && ClassUtils.isUserLevelMethod(method)) {
				return txAttr;
			}
		}

		return null;
	}

/**
 * TODO : 解析事务注解中的属性
 */
 protected TransactionAttribute parseTransactionAnnotation(AnnotationAttributes attributes) {
		RuleBasedTransactionAttribute rbta = new RuleBasedTransactionAttribute();
		// 获取事务传播属性
		Propagation propagation = attributes.getEnum("propagation");
		rbta.setPropagationBehavior(propagation.value());
		// 获取事务隔离等级
		Isolation isolation = attributes.getEnum("isolation");
		rbta.setIsolationLevel(isolation.value());
		// 获取事务获取事务超时时间
		rbta.setTimeout(attributes.getNumber("timeout").intValue());
		// 获取事务是否只读
		rbta.setReadOnly(attributes.getBoolean("readOnly"));
		// 获取事务事务管理器 bean的名称
		rbta.setQualifier(attributes.getString("value"));

		List<RollbackRuleAttribute> rollbackRules = new ArrayList<>();
		// 获取事务回滚相关配置
		for (Class<?> rbRule : attributes.getClassArray("rollbackFor")) {
			rollbackRules.add(new RollbackRuleAttribute(rbRule));
		}
		for (String rbRule : attributes.getStringArray("rollbackForClassName")) {
			rollbackRules.add(new RollbackRuleAttribute(rbRule));
		}
		for (Class<?> rbRule : attributes.getClassArray("noRollbackFor")) {
			rollbackRules.add(new NoRollbackRuleAttribute(rbRule));
		}
		for (String rbRule : attributes.getStringArray("noRollbackForClassName")) {
			rollbackRules.add(new NoRollbackRuleAttribute(rbRule));
		}
		rbta.setRollbackRules(rollbackRules);

		return rbta;
	}

/**
 * TODO : 根据给定的事务属性创建事务对象
 */
 protected TransactionInfo createTransactionIfNecessary(@Nullable PlatformTransactionManager tm,
			@Nullable TransactionAttribute txAttr, final String joinpointIdentification) {
		// 如果没有指定名称，则应用方法标识作为事务名称。
		// 读取事务方法调用的事务配置属性
		if (txAttr != null && txAttr.getName() == null) {
			// 如果事务名称为 null，则使用方法的名称(事务连接点标识)作为事务名称，
			// 调用一个实现 DelegatingTransactionAttribute 接口的匿名内部类
			txAttr = new DelegatingTransactionAttribute(txAttr) {
				@Override
				// 使用方法名称作为事务名称
				public String getName() {
					return joinpointIdentification;
				}
			};
		}
		// 事务状态封装了事务执行的状态信息
		TransactionStatus status = null;
		if (txAttr != null) {
			if (tm != null) {
				// 事务处理器创建事务，并且返回当前事务的状态信息
				// 核心方法，真正底层创建事务对象的方法
				status = tm.getTransaction(txAttr);
			}
			else {
				if (logger.isDebugEnabled()) {
					logger.debug("Skipping transactional joinpoint [" + joinpointIdentification +
							"] because no transaction manager has been configured");
				}
			}
		}
		// 准备事务信息，事务信息 TransactionInfo 封装了事务配置和状态信息
		return prepareTransactionInfo(tm, txAttr, joinpointIdentification, status);
	}

public final TransactionStatus getTransaction(@Nullable TransactionDefinition definition) throws TransactionException {
		// doGetTransaction()方法是抽象方法，具体的实现由具体的事务处理器提供
		Object transaction = doGetTransaction();

		// Cache debug flag to avoid repeated checks.
		boolean debugEnabled = logger.isDebugEnabled();
		// 如果没有配置事务属性，则使用默认的事务属性
		if (definition == null) {
			// Use defaults if no transaction definition given.
			definition = new DefaultTransactionDefinition();
		}
		// 检查当前线程是否存在事务，如果已存在事务，那么需要根据在事务属性中定义的事务传播属性来处理事务的产生（检查传播行为）
		if (isExistingTransaction(transaction)) {
			// Existing transaction found -> check propagation behavior to find out how to behave.
			// 处理已存在的事务的情况
			return handleExistingTransaction(definition, transaction, debugEnabled);
		}

		// Check definition settings for new transaction.
		// 检查事务属性中timeout超时属性设置是否合理
		if (definition.getTimeout() < TransactionDefinition.TIMEOUT_DEFAULT) {
			throw new InvalidTimeoutException("Invalid transaction timeout", definition.getTimeout());
		}

		// No existing transaction found -> check propagation behavior to find out how to proceed.
		// 对事务属性中配置的事务传播特性处理
		// 如果当前获取不到存在的事务，且事务传播特性配置的是 mandatory，当前没有事务存在，抛出异常
		if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_MANDATORY) {
			throw new IllegalTransactionStateException(
					"No existing transaction found for transaction marked with propagation 'mandatory'");
		}
		// 获取不到存在的事务，并且事务传播属性是 REQUIRED、REQUIRES_NEW、NESTED
		// 则执行事务挂起，新建事务。
		else if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_REQUIRED ||
				definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_REQUIRES_NEW ||
				definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_NESTED) {
			// 挂起当前事务
			SuspendedResourcesHolder suspendedResources = suspend(null);
			if (debugEnabled) {
				logger.debug("Creating new transaction with name [" + definition.getName() + "]: " + definition);
			}
			try {
				// 不激活和当前线程绑定的事务，因为事务传播特性配置要求创建新的事务
				boolean newSynchronization = (getTransactionSynchronization() != SYNCHRONIZATION_NEVER);
				// 创建一个新的事务状态
				DefaultTransactionStatus status = newTransactionStatus(
						definition, transaction, true, newSynchronization, debugEnabled, suspendedResources);
				// 核心方法：创建事务的调用，具体实现由具体的事务处理器提供。
				// 设置事务隔离级别（spring默认的事务隔离级别是跟JDBC相同的，即默认情况Spring不设置事务隔离级别）；
				doBegin(transaction, definition);
				// 初始化和同步事务状态
				prepareSynchronization(status, definition);
				return status;
			}
			catch (RuntimeException | Error ex) {
				resume(null, suspendedResources);
				throw ex;
			}
		}
		else {
			// Create "empty" transaction: no actual transaction, but potentially synchronization.
			if (definition.getIsolationLevel() != TransactionDefinition.ISOLATION_DEFAULT && logger.isWarnEnabled()) {
				logger.warn("Custom isolation level specified but no actual transaction initiated; " +
						"isolation level will effectively be ignored: " + definition);
			}
			// 创建空事务，针对 supported 类型的事务传播特性，激活和当前线程绑定的事务
			boolean newSynchronization = (getTransactionSynchronization() == SYNCHRONIZATION_ALWAYS);
			// 准备事务状态
			return prepareTransactionStatus(definition, null, true, newSynchronization, debugEnabled, null);
		}
	}

protected Object doGetTransaction() {
		// 管理 connection对象，创建回滚点，按照回滚点回滚，释放回滚点
		// DataSourceTransactionObject 就是真正的事务对象
		DataSourceTransactionObject txObject = new DataSourceTransactionObject();
		// DataSourceTransactionManager 默认是允许嵌套事务的
		txObject.setSavepointAllowed(isNestedTransactionAllowed());
		// obtainDataSource() 获取数据源对象，其实就是数据库连接对象
		// ConnectionHolder 持有了 Connection，并对 Connection进行了包装
		ConnectionHolder conHolder =
				(ConnectionHolder) TransactionSynchronizationManager.getResource(obtainDataSource());
		txObject.setConnectionHolder(conHolder, false);
		return txObject;
	}

public static Object getResource(Object key) {
		// 查看数据源连接池有没有扩展，一般没有
		Object actualKey = TransactionSynchronizationUtils.unwrapResourceIfNecessary(key);
		Object value = doGetResource(actualKey);
		if (value != null && logger.isTraceEnabled()) {
			logger.trace("Retrieved value [" + value + "] for key [" + actualKey + "] bound to thread [" +
					Thread.currentThread().getName() + "]");
		}
		return value;
	}

private static Object doGetResource(Object actualKey) {
		// 事务默认传播属性会共用同一个连接，因此会去 ThreadLocal 中获取连接，如果存在就直接返回
		// map对应了当前数据源对象和 当前连接的绑定关系
		Map<Object, Object> map = resources.get();
		if (map == null) {
			return null;
		}
		Object value = map.get(actualKey);
		// Transparently remove ResourceHolder that was marked as void...
		if (value instanceof ResourceHolder && ((ResourceHolder) value).isVoid()) {
			map.remove(actualKey);
			// Remove entire ThreadLocal if empty...
			if (map.isEmpty()) {
				resources.remove();
			}
			value = null;
		}
		return value;
	}

protected void doBegin(Object transaction, TransactionDefinition definition) {
		DataSourceTransactionObject txObject = (DataSourceTransactionObject) transaction;
		Connection con = null;

		try {
			// 如果没有数据库连接
			if (!txObject.hasConnectionHolder() ||
					txObject.getConnectionHolder().isSynchronizedWithTransaction()) {
				// 从连接池里面获取连接
				Connection newCon = obtainDataSource().getConnection();
				if (logger.isDebugEnabled()) {
					logger.debug("Acquired Connection [" + newCon + "] for JDBC transaction");
				}
				// 把连接包装成 ConnectionHolder，然后设置到事务对象中
				txObject.setConnectionHolder(new ConnectionHolder(newCon), true);
			}

			txObject.getConnectionHolder().setSynchronizedWithTransaction(true);
			con = txObject.getConnectionHolder().getConnection();
			// 从数据库连接中获取隔离级别，Mysql默认隔离级别是 可重复读
			Integer previousIsolationLevel = DataSourceUtils.prepareConnectionForTransaction(con, definition);
			txObject.setPreviousIsolationLevel(previousIsolationLevel);

			if (con.getAutoCommit()) {
				txObject.setMustRestoreAutoCommit(true);
				if (logger.isDebugEnabled()) {
					logger.debug("Switching JDBC Connection [" + con + "] to manual commit");
				}
				// 关闭连接的自动提交，其实这步就是开启了事务
				con.setAutoCommit(false);
			}
			// 设置只读事务 从这一点设置的时间点开始（时间点a）到这个事务结束的过程中，
			// 其他事务所提交的数据，该事务将看不见！
			// 设置只读事务就是告诉数据库，我这个事务内没有新增，修改，删除操作
			// 只有查询操作，不需要数据库锁等操作，减少数据库压力
			prepareTransactionalConnection(con, definition);
			// 自己提交关闭了，就说明已经开启事务了，事务是活动的
			txObject.getConnectionHolder().setTransactionActive(true);

			int timeout = determineTimeout(definition);
			if (timeout != TransactionDefinition.TIMEOUT_DEFAULT) {
				txObject.getConnectionHolder().setTimeoutInSeconds(timeout);
			}

			// Bind the connection holder to the thread.
			if (txObject.isNewConnectionHolder()) {
				// 如果是新创建的事务，则建立当前线程和数据库连接的关系
				TransactionSynchronizationManager.bindResource(obtainDataSource(), txObject.getConnectionHolder());
			}
		}

		catch (Throwable ex) {
			if (txObject.isNewConnectionHolder()) {
				DataSourceUtils.releaseConnection(con, obtainDataSource());
				txObject.setConnectionHolder(null, false);
			}
			throw new CannotCreateTransactionException("Could not open JDBC Connection for transaction", ex);
		}
	}